<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html>
        <head>
          <title>PartitionsIndexLuceneRDD - it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD</title>
          <meta name="description" content="PartitionsIndexLuceneRDD - it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD" />
          <meta name="keywords" content="PartitionsIndexLuceneRDD it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD" />
          <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
          
      <link href="../../../../../../lib/template.css" media="screen" type="text/css" rel="stylesheet" />
      <link href="../../../../../../lib/diagrams.css" media="screen" type="text/css" rel="stylesheet" id="diagrams-css" />
      <script type="text/javascript">
         if(top === self) {
            var url = '../../../../../../index.html';
            var hash = 'it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD';
            var anchor = window.location.hash;
            var anchor_opt = '';
            if (anchor.length >= 1)
              anchor_opt = '@' + anchor.substring(1);
            window.location.href = url + '#' + hash + anchor_opt;
         }
   	  </script>
    
        </head>
        <body class="type">
      <div id="definition">
        <a href="PartitionsIndexLuceneRDD$.html" title="Go to companion"><img src="../../../../../../lib/class_to_object_big.png" /></a>
        <p id="owner"><a href="../../../../../package.html" class="extype" name="it">it</a>.<a href="../../../../package.html" class="extype" name="it.agilelab">agilelab</a>.<a href="../../../package.html" class="extype" name="it.agilelab.bigdata">bigdata</a>.<a href="../../package.html" class="extype" name="it.agilelab.bigdata.spark">spark</a>.<a href="../package.html" class="extype" name="it.agilelab.bigdata.spark.search">search</a>.<a href="package.html" class="extype" name="it.agilelab.bigdata.spark.search.impl">impl</a></p>
        <h1><a href="PartitionsIndexLuceneRDD$.html" title="Go to companion">PartitionsIndexLuceneRDD</a></h1>
      </div>

      <h4 id="signature" class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">class</span>
      </span>
      <span class="symbol">
        <span class="name">PartitionsIndexLuceneRDD</span><span class="tparams">[<span name="T">T</span>]</span><span class="result"> extends <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      
          <div id="comment" class="fullcommenttop"><div class="comment cmt"><p>Implements SearchableRDD as an RDD of LuceneIndexedPartition
</p></div><div class="toggleContainer block">
          <span class="toggle">Linear Supertypes</span>
          <div class="superTypes hiddenContent"><a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>], <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>], <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Logging" class="extype" target="_top">Logging</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Serializable" class="extype" target="_top">Serializable</a>, <span class="extype" name="java.io.Serializable">Serializable</span>, <span class="extype" name="scala.AnyRef">AnyRef</span>, <span class="extype" name="scala.Any">Any</span></div>
        </div></div>
        

      <div id="mbrsel">
        <div id="textfilter"><span class="pre"></span><span class="input"><input id="mbrsel-input" type="text" accesskey="/" /></span><span class="post"></span></div>
        <div id="order">
              <span class="filtertype">Ordering</span>
              <ol>
                <li class="group out"><span>Grouped</span></li>
                <li class="alpha in"><span>Alphabetic</span></li>
                <li class="inherit out"><span>By inheritance</span></li>
              </ol>
            </div>
        <div id="ancestors">
                <span class="filtertype">Inherited<br />
                </span>
                <ol id="linearization">
                  <li class="in" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD"><span>PartitionsIndexLuceneRDD</span></li><li class="in" name="it.agilelab.bigdata.spark.search.SearchableRDD"><span>SearchableRDD</span></li><li class="in" name="org.apache.spark.rdd.RDD"><span>RDD</span></li><li class="in" name="org.apache.spark.Logging"><span>Logging</span></li><li class="in" name="scala.Serializable"><span>Serializable</span></li><li class="in" name="java.io.Serializable"><span>Serializable</span></li><li class="in" name="scala.AnyRef"><span>AnyRef</span></li><li class="in" name="scala.Any"><span>Any</span></li>
                </ol>
              </div><div id="ancestors">
            <span class="filtertype"></span>
            <ol>
              <li class="hideall out"><span>Hide All</span></li>
              <li class="showall in"><span>Show all</span></li>
            </ol>
            <a href="http://docs.scala-lang.org/overviews/scaladoc/usage.html#members" target="_blank">Learn more about member selection</a>
          </div>
        <div id="visbl">
            <span class="filtertype">Visibility</span>
            <ol><li class="public in"><span>Public</span></li><li class="all out"><span>All</span></li></ol>
          </div>
      </div>

      <div id="template">
        <div id="allMembers">
        

        

        

        <div id="values" class="values members">
              <h3>Value Members</h3>
              <ol><li name="scala.AnyRef#!=" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="!=(x$1:AnyRef):Boolean"></a>
      <a id="!=(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span title="gt4s: $bang$eq" class="name">!=</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.AnyRef">AnyRef</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="scala.Any#!=" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="!=(x$1:Any):Boolean"></a>
      <a id="!=(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span title="gt4s: $bang$eq" class="name">!=</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.Any">Any</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li name="scala.AnyRef###" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="##():Int"></a>
      <a id="##():Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span title="gt4s: $hash$hash" class="name">##</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#++" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="++(other:org.apache.spark.rdd.RDD[T]):org.apache.spark.rdd.RDD[T]"></a>
      <a id="++(RDD[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span title="gt4s: $plus$plus" class="name">++</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#==" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="==(x$1:AnyRef):Boolean"></a>
      <a id="==(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span title="gt4s: $eq$eq" class="name">==</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.AnyRef">AnyRef</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="scala.Any#==" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="==(x$1:Any):Boolean"></a>
      <a id="==(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span title="gt4s: $eq$eq" class="name">==</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.Any">Any</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#aggregate" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="aggregate[U](zeroValue:U)(seqOp:(U,T)=&gt;U,combOp:(U,U)=&gt;U)(implicitevidence$33:scala.reflect.ClassTag[U]):U"></a>
      <a id="aggregate[U](U)((U,T)⇒U,(U,U)⇒U)(ClassTag[U]):U"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">aggregate</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="zeroValue">zeroValue: <span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span></span>)</span><span class="params">(<span name="seqOp">seqOp: (<span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span>, <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span></span>, <span name="combOp">combOp: (<span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span>, <span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span>]</span>)</span><span class="result">: <span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#aggregatingSearch" visbl="pub" data-isabs="false" fullComment="yes" group="Search">
      <a id="aggregatingSearch(query:it.agilelab.bigdata.spark.search.Query,maxHits:Int,maxHitsPerIndex:Int):Array[(T,Double)]"></a>
      <a id="aggregatingSearch(Query,Int,Int):Array[(T,Double)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">aggregatingSearch</span><span class="params">(<span name="query">query: <a href="../Query.html" class="extype" name="it.agilelab.bigdata.spark.search.Query">Query</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="../../../../../package.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns an <code>Array</code> of elements matching the <code>query</code> with their scores, returning at most
<code>maxHits</code> results.</p><div class="fullcomment"><div class="comment cmt"><p>Returns an <code>Array</code> of elements matching the <code>query</code> with their scores, returning at most
<code>maxHits</code> results.</p><p>Setting <code>maxHitsPerIndex</code> limits the size of intermediate results. It must be a positive value
between <code>1</code> and <code>maxHits</code> (both inclusive). The (internally handled) default is <code>maxHits</code>.</p><p>The resulting <code>Array</code> is produced by efficiently aggregating partial results in a tree-level
pattern.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd><dt>Note</dt><dd><span class="cmt"><p>Setting the maximum number of intermediate results to be lower than
                            the maximum number of results can lead to good results not being
                            returned, especially with non-uniform data distributions.
</p></span></dd><dt>See also</dt><dd><span class="cmt"><p><a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD@treeAggregate[U](zeroValue:U)(seqOp:(U,T)=&gt;U,combOp:(U,U)=&gt;U,depth:Int)(implicitevidence$34:scala.reflect.ClassTag[U]):U" class="extype" target="_top">org.apache.spark.rdd.RDD#treeAggregate</a>
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#aggregatingSearchWithResultsTransformer" visbl="pub" data-isabs="false" fullComment="yes" group="Search">
      <a id="aggregatingSearchWithResultsTransformer[V](query:it.agilelab.bigdata.spark.search.Query,maxHits:Int,resultsTransformer:T=&gt;V,maxHitsPerIndex:Int):Array[(V,Double)]"></a>
      <a id="aggregatingSearchWithResultsTransformer[V](Query,Int,(T)⇒V,Int):Array[(V,Double)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">aggregatingSearchWithResultsTransformer</span><span class="tparams">[<span name="V">V</span>]</span><span class="params">(<span name="query">query: <a href="../Query.html" class="extype" name="it.agilelab.bigdata.spark.search.Query">Query</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="resultsTransformer">resultsTransformer: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.aggregatingSearchWithResultsTransformer.V">V</span></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="../../../../../package.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.aggregatingSearchWithResultsTransformer.V">V</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="aggregatingSearchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">aggregatingSearch(Query,Int,Int)</span>,
but specifying a <code>resultsTransformer</code> function to be applied to the result elements.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="aggregatingSearchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">aggregatingSearch(Query,Int,Int)</span>,
but specifying a <code>resultsTransformer</code> function to be applied to the result elements.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="scala.Any#asInstanceOf" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="asInstanceOf[T0]:T0"></a>
      <a id="asInstanceOf[T0]:T0"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">asInstanceOf</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="result">: <span class="extype" name="scala.Any.asInstanceOf.T0">T0</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#batchSearch" visbl="pub" data-isabs="false" fullComment="yes" group="Search">
      <a id="batchSearch(queries:Iterable[(Long,it.agilelab.bigdata.spark.search.dsl.DslQuery)],maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(T,Double)])]"></a>
      <a id="batchSearch(Iterable[(Long,DslQuery)],Int,Int):RDD[(Long,Array[(T,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">batchSearch</span><span class="params">(<span name="queries">queries: <span class="extype" name="scala.Iterable">Iterable</span>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a>)]</span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="../../../../../package.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns an <code>RDD</code> of elements matching the <code>queries</code>, returning at most <code>maxHits</code> results for
each query.</p><div class="fullcomment"><div class="comment cmt"><p>Returns an <code>RDD</code> of elements matching the <code>queries</code>, returning at most <code>maxHits</code> results for
each query.</p><p>The queries must be provided with a unique id for each query, as an <code>Iterator</code> of <code>(id, query)</code>
pairs. The results of each query are returned associated with this unique id as <code>(id, results)</code>
pairs in the returned RDD; each <code>results</code> is an <code>Array</code> of <code>(element, score)</code> pairs.</p><p>Setting <code>maxHitsPerIndex</code> limits the size of intermediate results. It must be a positive value
between <code>1</code> and <code>maxHits</code> (both inclusive). The (internally handled) default is <code>maxHits</code>.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd><dt>Note</dt><dd><span class="cmt"><p>Setting the maximum number of intermediate results to be lower than
                            the maximum number of results can lead to good results not being
                            returned, especially with non-uniform data distributions.
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#batchSearchRaw" visbl="pub" data-isabs="false" fullComment="yes" group="Search">
      <a id="batchSearchRaw(queries:Iterator[(Long,it.agilelab.bigdata.spark.search.RawQuery)],maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(T,Double)])]"></a>
      <a id="batchSearchRaw(Iterator[(Long,RawQuery)],Int,Int):RDD[(Long,Array[(T,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">batchSearchRaw</span><span class="params">(<span name="queries">queries: <span class="extype" name="scala.Iterator">Iterator</span>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="../RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a>)]</span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="../../../../../package.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="batchSearchWithResultsTransformer(queries:Iterator[(Long,it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery)],maxHits:Int,maxHitsPerIndex:Int)*">batchSearch(Iterator[(Long,DslQuery)],Int,Int)</span>,
but uses <a href="../RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a> type queries instead of <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">dsl.DslQuery</a>.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="batchSearchWithResultsTransformer(queries:Iterator[(Long,it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery)],maxHits:Int,maxHitsPerIndex:Int)*">batchSearch(Iterator[(Long,DslQuery)],Int,Int)</span>,
but uses <a href="../RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a> type queries instead of <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">dsl.DslQuery</a>.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#batchSearchRawWithResultsTransformer" visbl="pub" data-isabs="false" fullComment="yes" group="Search">
      <a id="batchSearchRawWithResultsTransformer[V](queries:Iterator[(Long,it.agilelab.bigdata.spark.search.RawQuery)],maxHits:Int,resultsTransformer:T=&gt;V,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(V,Double)])]"></a>
      <a id="batchSearchRawWithResultsTransformer[V](Iterator[(Long,RawQuery)],Int,(T)⇒V,Int):RDD[(Long,Array[(V,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">batchSearchRawWithResultsTransformer</span><span class="tparams">[<span name="V">V</span>]</span><span class="params">(<span name="queries">queries: <span class="extype" name="scala.Iterator">Iterator</span>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="../RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a>)]</span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="resultsTransformer">resultsTransformer: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.batchSearchRawWithResultsTransformer.V">V</span></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="../../../../../package.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.batchSearchRawWithResultsTransformer.V">V</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <a href="#batchSearchWithResultsTransformer[V](queries:Iterator[(Long,it.agilelab.bigdata.spark.search.dsl.DslQuery)],maxHits:Int,resultsTransformer:T=&gt;V,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(V,Double)])]" class="extmbr" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#batchSearchWithResultsTransformer">batchSearch(Iterator[(Long,DslQuery)],Int,T=&gt;V,Int)</a>,
but uses <a href="../RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a> type queries instead of <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">dsl.DslQuery</a>.</p><div class="fullcomment"><div class="comment cmt"><p>Like <a href="#batchSearchWithResultsTransformer[V](queries:Iterator[(Long,it.agilelab.bigdata.spark.search.dsl.DslQuery)],maxHits:Int,resultsTransformer:T=&gt;V,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(V,Double)])]" class="extmbr" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#batchSearchWithResultsTransformer">batchSearch(Iterator[(Long,DslQuery)],Int,T=&gt;V,Int)</a>,
but uses <a href="../RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a> type queries instead of <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">dsl.DslQuery</a>.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#batchSearchWithResultsTransformer" visbl="pub" data-isabs="false" fullComment="yes" group="Search">
      <a id="batchSearchWithResultsTransformer[V](queries:Iterator[(Long,it.agilelab.bigdata.spark.search.dsl.DslQuery)],maxHits:Int,resultsTransformer:T=&gt;V,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(V,Double)])]"></a>
      <a id="batchSearchWithResultsTransformer[V](Iterator[(Long,DslQuery)],Int,(T)⇒V,Int):RDD[(Long,Array[(V,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">batchSearchWithResultsTransformer</span><span class="tparams">[<span name="V">V</span>]</span><span class="params">(<span name="queries">queries: <span class="extype" name="scala.Iterator">Iterator</span>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a>)]</span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="resultsTransformer">resultsTransformer: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.batchSearchWithResultsTransformer.V">V</span></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="../../../../../package.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.batchSearchWithResultsTransformer.V">V</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="batchSearchWithResultsTransformer(queries:Iterator[(Long,it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery)],maxHits:Int,maxHitsPerIndex:Int)*">batchSearch(Iterator[(Long,DslQuery)],Int,Int)</span>,
but specifying a <code>resultsTransformer</code> function to be applied to the result elements.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="batchSearchWithResultsTransformer(queries:Iterator[(Long,it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery)],maxHits:Int,maxHitsPerIndex:Int)*">batchSearch(Iterator[(Long,DslQuery)],Int,Int)</span>,
but specifying a <code>resultsTransformer</code> function to be applied to the result elements.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#cache" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="cache():RDD.this.type"></a>
      <a id="cache():PartitionsIndexLuceneRDD.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">cache</span><span class="params">()</span><span class="result">: <a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a>.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#cartesian" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="cartesian[U](other:org.apache.spark.rdd.RDD[U])(implicitevidence$5:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[(T,U)]"></a>
      <a id="cartesian[U](RDD[U])(ClassTag[U]):RDD[(T,U)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">cartesian</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.cartesian.U">U</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.cartesian.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.cartesian.U">U</span>)]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#checkpoint" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="checkpoint():Unit"></a>
      <a id="checkpoint():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">checkpoint</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#clearDependencies" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="clearDependencies():Unit"></a>
      <a id="clearDependencies():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">clearDependencies</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#clone" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="clone():Object"></a>
      <a id="clone():AnyRef"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">clone</span><span class="params">()</span><span class="result">: <span class="extype" name="scala.AnyRef">AnyRef</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a href="../../../../../../java$lang.html" class="extype" name="java.lang">java.lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">(<span>
      
      <span class="defval" name="classOf[java.lang.CloneNotSupportedException]">...</span>
    </span>)</span>
              
        </dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#coalesce" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="coalesce(numPartitions:Int,shuffle:Boolean)(implicitord:Ordering[T]):org.apache.spark.rdd.RDD[T]"></a>
      <a id="coalesce(Int,Boolean)(Ordering[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">coalesce</span><span class="params">(<span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="shuffle">shuffle: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#collect" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="collect[U](f:PartialFunction[T,U])(implicitevidence$32:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="collect[U](PartialFunction[T,U])(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">collect</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.PartialFunction" class="extype" target="_top">PartialFunction</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.collect.U">U</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.collect.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.collect.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#collect" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="collect():Array[T]"></a>
      <a id="collect():Array[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">collect</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#compute" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="compute(split:org.apache.spark.Partition,context:org.apache.spark.TaskContext):Iterator[T]"></a>
      <a id="compute(Partition,TaskContext):Iterator[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">compute</span><span class="params">(<span name="split">split: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partition" class="extype" target="_top">Partition</a></span>, <span name="context">context: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.TaskContext" class="extype" target="_top">TaskContext</a></span>)</span><span class="result">: <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Overrides the compute function to return an iterator over the elements.</p><div class="fullcomment"><div class="comment cmt"><p>Overrides the compute function to return an iterator over the elements.
 Returns iterators from the storage Arrays in each IndexedPartition.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#config" visbl="pub" data-isabs="false" fullComment="no" group="Ungrouped">
      <a id="config:it.agilelab.bigdata.spark.search.impl.LuceneConfig"></a>
      <a id="config:LuceneConfig"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">val</span>
      </span>
      <span class="symbol">
        <span class="name">config</span><span class="result">: <a href="LuceneConfig.html" class="extype" name="it.agilelab.bigdata.spark.search.impl.LuceneConfig">LuceneConfig</a></span>
      </span>
      </h4>
      
    </li><li name="org.apache.spark.rdd.RDD#context" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="context:org.apache.spark.SparkContext"></a>
      <a id="context:SparkContext"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">context</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.SparkContext" class="extype" target="_top">SparkContext</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#count" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="count():Long"></a>
      <a id="count():Long"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">count</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#countApprox" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="countApprox(timeout:Long,confidence:Double):org.apache.spark.partial.PartialResult[org.apache.spark.partial.BoundedDouble]"></a>
      <a id="countApprox(Long,Double):PartialResult[BoundedDouble]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">countApprox</span><span class="params">(<span name="timeout">timeout: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>, <span name="confidence">confidence: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a></span>)</span><span class="result">: <span class="extype" name="org.apache.spark.partial.PartialResult">PartialResult</span>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.partial.BoundedDouble" class="extype" target="_top">BoundedDouble</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#countApproxDistinct" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="countApproxDistinct(relativeSD:Double):Long"></a>
      <a id="countApproxDistinct(Double):Long"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">countApproxDistinct</span><span class="params">(<span name="relativeSD">relativeSD: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#countApproxDistinct" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="countApproxDistinct(p:Int,sp:Int):Long"></a>
      <a id="countApproxDistinct(Int,Int):Long"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">countApproxDistinct</span><span class="params">(<span name="p">p: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="sp">sp: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#countByValue" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="countByValue()(implicitord:Ordering[T]):scala.collection.Map[T,Long]"></a>
      <a id="countByValue()(Ordering[T]):Map[T,Long]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">countByValue</span><span class="params">()</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.collection.Map" class="extype" target="_top">Map</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#countByValueApprox" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="countByValueApprox(timeout:Long,confidence:Double)(implicitord:Ordering[T]):org.apache.spark.partial.PartialResult[scala.collection.Map[T,org.apache.spark.partial.BoundedDouble]]"></a>
      <a id="countByValueApprox(Long,Double)(Ordering[T]):PartialResult[Map[T,BoundedDouble]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">countByValueApprox</span><span class="params">(<span name="timeout">timeout: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>, <span name="confidence">confidence: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <span class="extype" name="org.apache.spark.partial.PartialResult">PartialResult</span>[<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.collection.Map" class="extype" target="_top">Map</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.partial.BoundedDouble" class="extype" target="_top">BoundedDouble</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#dependencies" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="dependencies:Seq[org.apache.spark.Dependency[_]]"></a>
      <a id="dependencies:Seq[Dependency[_]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">dependencies</span><span class="result">: <span class="extype" name="scala.Seq">Seq</span>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Dependency" class="extype" target="_top">Dependency</a>[_]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#distinct" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="distinct():org.apache.spark.rdd.RDD[T]"></a>
      <a id="distinct():RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">distinct</span><span class="params">()</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#distinct" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="distinct(numPartitions:Int)(implicitord:Ordering[T]):org.apache.spark.rdd.RDD[T]"></a>
      <a id="distinct(Int)(Ordering[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">distinct</span><span class="params">(<span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#eq" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="eq(x$1:AnyRef):Boolean"></a>
      <a id="eq(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">eq</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.AnyRef">AnyRef</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="scala.AnyRef#equals" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="equals(x$1:Any):Boolean"></a>
      <a id="equals(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">equals</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.Any">Any</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#filter" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="filter(f:T=&gt;Boolean):org.apache.spark.rdd.RDD[T]"></a>
      <a id="filter((T)⇒Boolean):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">filter</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#finalize" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="finalize():Unit"></a>
      <a id="finalize():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">finalize</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a href="../../../../../../java$lang.html" class="extype" name="java.lang">java.lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">(<span>
      
      <span class="symbol">classOf[java.lang.Throwable]</span>
    </span>)</span>
              
        </dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#first" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="first():T"></a>
      <a id="first():T"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">first</span><span class="params">()</span><span class="result">: <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#firstParent" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="firstParent[U](implicitevidence$35:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="firstParent[U](ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">firstParent</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.firstParent.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.firstParent.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a href="../../../../../../org$apache$spark.html" class="extype" name="org.apache.spark">org.apache.spark</a>] </dd><dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#flatMap" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="flatMap[U](f:T=&gt;TraversableOnce[U])(implicitevidence$4:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="flatMap[U]((T)⇒TraversableOnce[U])(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">flatMap</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="scala.TraversableOnce">TraversableOnce</span>[<span class="extype" name="org.apache.spark.rdd.RDD.flatMap.U">U</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.flatMap.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.flatMap.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#fold" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="fold(zeroValue:T)(op:(T,T)=&gt;T):T"></a>
      <a id="fold(T)((T,T)⇒T):T"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">fold</span><span class="params">(<span name="zeroValue">zeroValue: <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span></span>)</span><span class="params">(<span name="op">op: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span></span>)</span><span class="result">: <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#foreach" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="foreach(f:T=&gt;Unit):Unit"></a>
      <a id="foreach((T)⇒Unit):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">foreach</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#foreachPartition" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="foreachPartition(f:Iterator[T]=&gt;Unit):Unit"></a>
      <a id="foreachPartition((Iterator[T])⇒Unit):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">foreachPartition</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#getCheckpointFile" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getCheckpointFile:Option[String]"></a>
      <a id="getCheckpointFile:Option[String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getCheckpointFile</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Option" class="extype" target="_top">Option</a>[<span class="extype" name="scala.Predef.String">String</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#getClass" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getClass():Class[_]"></a>
      <a id="getClass():Class[_]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getClass</span><span class="params">()</span><span class="result">: <span class="extype" name="java.lang.Class">Class</span>[_]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#getConfigInfo" visbl="pub" data-isabs="false" fullComment="no" group="Ungrouped">
      <a id="getConfigInfo:String"></a>
      <a id="getConfigInfo:String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getConfigInfo</span><span class="result">: <span class="extype" name="scala.Predef.String">String</span></span>
      </span>
      </h4>
      
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#getDataAndIndicesInfo" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getDataAndIndicesInfo:String"></a>
      <a id="getDataAndIndicesInfo:String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getDataAndIndicesInfo</span><span class="result">: <span class="extype" name="scala.Predef.String">String</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Produces a string description of the number and size of data and indices of this LuceneRDD.</p><div class="fullcomment"><div class="comment cmt"><p>Produces a string description of the number and size of data and indices of this LuceneRDD.
WARNING: this will cause the parent RDD to be materialized and indexed!
</p></div><dl class="paramcmts block"><dt>returns</dt><dd class="cmt"><p>a string describing this RDD
</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#getDependencies" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getDependencies:Seq[org.apache.spark.Dependency[_]]"></a>
      <a id="getDependencies:Seq[Dependency[_]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getDependencies</span><span class="result">: <span class="extype" name="scala.Seq">Seq</span>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Dependency" class="extype" target="_top">Dependency</a>[_]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#getDocumentCounts" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getDocumentCounts:Map[String,Long]"></a>
      <a id="getDocumentCounts:Map[String,Long]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getDocumentCounts</span><span class="result">: <span class="extype" name="scala.Predef.Map">Map</span>[<span class="extype" name="scala.Predef.String">String</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns the document counts for this SearchableRDD.</p><div class="fullcomment"><div class="comment cmt"><p>Returns the document counts for this SearchableRDD.
The key for the map is the field name; the value is the number of documents.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#getElement" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getElement(id:Long):Option[T]"></a>
      <a id="getElement(Long):Option[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getElement</span><span class="params">(<span name="id">id: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Option" class="extype" target="_top">Option</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns the element of this <code>SearchableRDD</code> with corresponds to the provided <code>id</code>, if it exists.</p><div class="fullcomment"><div class="comment cmt"><p>Returns the element of this <code>SearchableRDD</code> with corresponds to the provided <code>id</code>, if it exists.</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#getElements" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getElements(ids:Array[Long]):Array[(Long,Option[T])]"></a>
      <a id="getElements(Array[Long]):Array[(Long,Option[T])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getElements</span><span class="params">(<span name="ids">ids: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>]</span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Option" class="extype" target="_top">Option</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <a href="#getElement(id:Long):Option[T]" class="extmbr" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#getElement">getElement(Long)</a>, but for an <code>Array</code> of ids.</p><div class="fullcomment"><div class="comment cmt"><p>Like <a href="#getElement(id:Long):Option[T]" class="extmbr" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#getElement">getElement(Long)</a>, but for an <code>Array</code> of ids.</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#getIndicesInfo" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getIndicesInfo:it.agilelab.bigdata.spark.search.IndicesInfo"></a>
      <a id="getIndicesInfo:IndicesInfo"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getIndicesInfo</span><span class="result">: <a href="../IndicesInfo.html" class="extype" name="it.agilelab.bigdata.spark.search.IndicesInfo">IndicesInfo</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns information about the indices.</p><div class="fullcomment"><div class="comment cmt"><p>Returns information about the indices.</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#getNumPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getNumPartitions:Int"></a>
      <a id="getNumPartitions:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getNumPartitions</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@Since</span><span class="args">(<span>
      
      <span class="symbol">&quot;1.6.0&quot;</span>
    </span>)</span>
              
        </dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#getPartitions" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getPartitions:Array[org.apache.spark.Partition]"></a>
      <a id="getPartitions:Array[Partition]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getPartitions</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partition" class="extype" target="_top">Partition</a>]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns the array of partitions.</p><div class="fullcomment"><div class="comment cmt"><p>Returns the array of partitions.
</p></div><dl class="paramcmts block"><dt>returns</dt><dd class="cmt"><p>The array of partitions.
</p></dd></dl><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#getPreferredLocations" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getPreferredLocations(split:org.apache.spark.Partition):Seq[String]"></a>
      <a id="getPreferredLocations(Partition):Seq[String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getPreferredLocations</span><span class="params">(<span name="split">split: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partition" class="extype" target="_top">Partition</a></span>)</span><span class="result">: <span class="extype" name="scala.Seq">Seq</span>[<span class="extype" name="scala.Predef.String">String</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#getStorageLevel" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getStorageLevel:org.apache.spark.storage.StorageLevel"></a>
      <a id="getStorageLevel:StorageLevel"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getStorageLevel</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.storage.StorageLevel" class="extype" target="_top">StorageLevel</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#getTermCounts" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getTermCounts:Map[String,Map[String,Long]]"></a>
      <a id="getTermCounts:Map[String,Map[String,Long]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getTermCounts</span><span class="result">: <span class="extype" name="scala.Predef.Map">Map</span>[<span class="extype" name="scala.Predef.String">String</span>, <span class="extype" name="scala.Predef.Map">Map</span>[<span class="extype" name="scala.Predef.String">String</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>]]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns the terms counts for this SearchableRDD.</p><div class="fullcomment"><div class="comment cmt"><p>Returns the terms counts for this SearchableRDD.
The key for the first map is the field name; the one for the second map is the term; the value is the number of
occurrences of the term in that field across all documents.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#getTermIDFs" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getTermIDFs:Map[String,Map[String,Float]]"></a>
      <a id="getTermIDFs:Map[String,Map[String,Float]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getTermIDFs</span><span class="result">: <span class="extype" name="scala.Predef.Map">Map</span>[<span class="extype" name="scala.Predef.String">String</span>, <span class="extype" name="scala.Predef.Map">Map</span>[<span class="extype" name="scala.Predef.String">String</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Float" class="extype" target="_top">Float</a>]]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns the term IDFs for this SearchableRDD.</p><div class="fullcomment"><div class="comment cmt"><p>Returns the term IDFs for this SearchableRDD.
The key for the first map is the field name; the one for the second map is the term; the value is the IDF of
of the term in that field.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#glom" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="glom():org.apache.spark.rdd.RDD[Array[T]]"></a>
      <a id="glom():RDD[Array[T]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">glom</span><span class="params">()</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#groupBy" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="groupBy[K](f:T=&gt;K,p:org.apache.spark.Partitioner)(implicitkt:scala.reflect.ClassTag[K],implicitord:Ordering[K]):org.apache.spark.rdd.RDD[(K,Iterable[T])]"></a>
      <a id="groupBy[K]((T)⇒K,Partitioner)(ClassTag[K],Ordering[K]):RDD[(K,Iterable[T])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">groupBy</span><span class="tparams">[<span name="K">K</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span></span>, <span name="p">p: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partitioner" class="extype" target="_top">Partitioner</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="kt">kt: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>]</span>, <span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>, <span class="extype" name="scala.Iterable">Iterable</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#groupBy" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="groupBy[K](f:T=&gt;K,numPartitions:Int)(implicitkt:scala.reflect.ClassTag[K]):org.apache.spark.rdd.RDD[(K,Iterable[T])]"></a>
      <a id="groupBy[K]((T)⇒K,Int)(ClassTag[K]):RDD[(K,Iterable[T])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">groupBy</span><span class="tparams">[<span name="K">K</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span></span>, <span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="kt">kt: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>, <span class="extype" name="scala.Iterable">Iterable</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#groupBy" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="groupBy[K](f:T=&gt;K)(implicitkt:scala.reflect.ClassTag[K]):org.apache.spark.rdd.RDD[(K,Iterable[T])]"></a>
      <a id="groupBy[K]((T)⇒K)(ClassTag[K]):RDD[(K,Iterable[T])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">groupBy</span><span class="tparams">[<span name="K">K</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="kt">kt: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>, <span class="extype" name="scala.Iterable">Iterable</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#hashCode" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="hashCode():Int"></a>
      <a id="hashCode():Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">hashCode</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#id" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="id:Int"></a>
      <a id="id:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">val</span>
      </span>
      <span class="symbol">
        <span class="name">id</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#indexedPartitionsRDD" visbl="pub" data-isabs="false" fullComment="no" group="Ungrouped">
      <a id="indexedPartitionsRDD:org.apache.spark.rdd.RDD[it.agilelab.bigdata.spark.search.impl.LuceneIndexedPartition[T]]"></a>
      <a id="indexedPartitionsRDD:RDD[LuceneIndexedPartition[T]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">val</span>
      </span>
      <span class="symbol">
        <span class="name">indexedPartitionsRDD</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<a href="LuceneIndexedPartition.html" class="extype" name="it.agilelab.bigdata.spark.search.impl.LuceneIndexedPartition">LuceneIndexedPartition</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]]</span>
      </span>
      </h4>
      
    </li><li name="org.apache.spark.rdd.RDD#intersection" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="intersection(other:org.apache.spark.rdd.RDD[T],numPartitions:Int):org.apache.spark.rdd.RDD[T]"></a>
      <a id="intersection(RDD[T],Int):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">intersection</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>, <span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#intersection" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="intersection(other:org.apache.spark.rdd.RDD[T],partitioner:org.apache.spark.Partitioner)(implicitord:Ordering[T]):org.apache.spark.rdd.RDD[T]"></a>
      <a id="intersection(RDD[T],Partitioner)(Ordering[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">intersection</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>, <span name="partitioner">partitioner: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partitioner" class="extype" target="_top">Partitioner</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#intersection" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="intersection(other:org.apache.spark.rdd.RDD[T]):org.apache.spark.rdd.RDD[T]"></a>
      <a id="intersection(RDD[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">intersection</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#isCheckpointed" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="isCheckpointed:Boolean"></a>
      <a id="isCheckpointed:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isCheckpointed</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#isEmpty" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="isEmpty():Boolean"></a>
      <a id="isEmpty():Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isEmpty</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.Any#isInstanceOf" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="isInstanceOf[T0]:Boolean"></a>
      <a id="isInstanceOf[T0]:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isInstanceOf</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li name="org.apache.spark.Logging#isTraceEnabled" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="isTraceEnabled():Boolean"></a>
      <a id="isTraceEnabled():Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isTraceEnabled</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#iterator" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="iterator(split:org.apache.spark.Partition,context:org.apache.spark.TaskContext):Iterator[T]"></a>
      <a id="iterator(Partition,TaskContext):Iterator[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">iterator</span><span class="params">(<span name="split">split: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partition" class="extype" target="_top">Partition</a></span>, <span name="context">context: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.TaskContext" class="extype" target="_top">TaskContext</a></span>)</span><span class="result">: <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#keyBy" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="keyBy[K](f:T=&gt;K):org.apache.spark.rdd.RDD[(K,T)]"></a>
      <a id="keyBy[K]((T)⇒K):RDD[(K,T)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">keyBy</span><span class="tparams">[<span name="K">K</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.keyBy.K">K</span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="org.apache.spark.rdd.RDD.keyBy.K">K</span>, <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>)]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#lightAggregatingSearch" visbl="pub" data-isabs="false" fullComment="yes" group="Search">
      <a id="lightAggregatingSearch(query:it.agilelab.bigdata.spark.search.Query,maxHits:Int,maxHitsPerIndex:Int):Array[(Long,Double)]"></a>
      <a id="lightAggregatingSearch(Query,Int,Int):Array[(Long,Double)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lightAggregatingSearch</span><span class="params">(<span name="query">query: <a href="../Query.html" class="extype" name="it.agilelab.bigdata.spark.search.Query">Query</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="../../../../../package.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="aggregatingSearchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">aggregatingSearch(Query,Int,Int)</span>,
but returns the ids of the resulting elements.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="aggregatingSearchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">aggregatingSearch(Query,Int,Int)</span>,
but returns the ids of the resulting elements.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd><dt>Note</dt><dd><span class="cmt"><p>These ids are ephemeral, and can change between instances of this RDD;
                     they are only meaningful when used in combination with the same RDD that
                     provided them.
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#lightBatchSearch" visbl="pub" data-isabs="false" fullComment="yes" group="Search">
      <a id="lightBatchSearch(queries:Iterator[(Long,it.agilelab.bigdata.spark.search.dsl.DslQuery)],maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(Long,Double)])]"></a>
      <a id="lightBatchSearch(Iterator[(Long,DslQuery)],Int,Int):RDD[(Long,Array[(Long,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lightBatchSearch</span><span class="params">(<span name="queries">queries: <span class="extype" name="scala.Iterator">Iterator</span>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a>)]</span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="../../../../../package.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="batchSearchWithResultsTransformer(queries:Iterator[(Long,it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery)],maxHits:Int,maxHitsPerIndex:Int)*">batchSearch(Iterator[(Long,DslQuery)],Int,Int)</span>,
but returns the ids of the resulting elements.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="batchSearchWithResultsTransformer(queries:Iterator[(Long,it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery)],maxHits:Int,maxHitsPerIndex:Int)*">batchSearch(Iterator[(Long,DslQuery)],Int,Int)</span>,
but returns the ids of the resulting elements.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd><dt>Note</dt><dd><span class="cmt"><p>These ids are ephemeral, and can change between instances of this RDD;
                     they are only meaningful when used in combination with the same RDD that
                     provided them.
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#lightBatchSearchRaw" visbl="pub" data-isabs="false" fullComment="yes" group="Search">
      <a id="lightBatchSearchRaw(queries:Iterator[(Long,it.agilelab.bigdata.spark.search.RawQuery)],maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(Long,Double)])]"></a>
      <a id="lightBatchSearchRaw(Iterator[(Long,RawQuery)],Int,Int):RDD[(Long,Array[(Long,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lightBatchSearchRaw</span><span class="params">(<span name="queries">queries: <span class="extype" name="scala.Iterator">Iterator</span>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="../RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a>)]</span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="../../../../../package.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <a href="#lightBatchSearch(queries:Iterator[(Long,it.agilelab.bigdata.spark.search.dsl.DslQuery)],maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(Long,Double)])]" class="extmbr" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#lightBatchSearch">lightBatchSearch(Iterator[(Long,DslQuery)],Int,Int)</a>,
but uses <a href="../RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a> type queries instead of <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">dsl.DslQuery</a>.</p><div class="fullcomment"><div class="comment cmt"><p>Like <a href="#lightBatchSearch(queries:Iterator[(Long,it.agilelab.bigdata.spark.search.dsl.DslQuery)],maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(Long,Double)])]" class="extmbr" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#lightBatchSearch">lightBatchSearch(Iterator[(Long,DslQuery)],Int,Int)</a>,
but uses <a href="../RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a> type queries instead of <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">dsl.DslQuery</a>.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#lightQueryJoin" visbl="pub" data-isabs="false" fullComment="yes" group="QueryJoin">
      <a id="lightQueryJoin[U](other:org.apache.spark.rdd.RDD[U],queryGenerator:U=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int)(implicitevidence$4:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[(U,Array[(Long,Double)])]"></a>
      <a id="lightQueryJoin[U](RDD[U],(U)⇒DslQuery,Int)(ClassTag[U]):RDD[(U,Array[(Long,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lightQueryJoin</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.lightQueryJoin.U">U</span>]</span>, <span name="queryGenerator">queryGenerator: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.lightQueryJoin.U">U</span>) ⇒ <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.lightQueryJoin.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.lightQueryJoin.U">U</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="queryJoinWithResultsTransformer[U](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int)*">queryJoin[U](RDD[U],U=&gt;DslQuery,Int)</span>,
but returns the ids of the resulting elements.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="queryJoinWithResultsTransformer[U](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int)*">queryJoin[U](RDD[U],U=&gt;DslQuery,Int)</span>,
but returns the ids of the resulting elements.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd><dt>Note</dt><dd><span class="cmt"><p>These ids are ephemeral, and can change between instances of this RDD;
                     they are only meaningful when used in combination with the same RDD that
                     provided them.
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#lightQueryJoin" visbl="pub" data-isabs="false" fullComment="yes" group="QueryJoin">
      <a id="lightQueryJoin(queryGenerator:T=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int):org.apache.spark.rdd.RDD[(T,Array[(Long,Double)])]"></a>
      <a id="lightQueryJoin((T)⇒DslQuery,Int):RDD[(T,Array[(Long,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lightQueryJoin</span><span class="params">(<span name="queryGenerator">queryGenerator: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <a href="#lightQueryJoin[U](other:org.apache.spark.rdd.RDD[U],queryGenerator:U=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int)(implicitevidence$4:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[(U,Array[(Long,Double)])]" class="extmbr" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#lightQueryJoin">lightQueryJoin[U](RDD[U],U=&gt;DslQuery,Int)</a>,
but with <code>this</code> as the <code>other</code> RDD; that is, a query self join.</p><div class="fullcomment"><div class="comment cmt"><p>Like <a href="#lightQueryJoin[U](other:org.apache.spark.rdd.RDD[U],queryGenerator:U=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int)(implicitevidence$4:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[(U,Array[(Long,Double)])]" class="extmbr" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#lightQueryJoin">lightQueryJoin[U](RDD[U],U=&gt;DslQuery,Int)</a>,
but with <code>this</code> as the <code>other</code> RDD; that is, a query self join.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#lightSearch" visbl="pub" data-isabs="false" fullComment="yes" group="Search">
      <a id="lightSearch(query:it.agilelab.bigdata.spark.search.Query,maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Double)]"></a>
      <a id="lightSearch(Query,Int,Int):RDD[(Long,Double)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lightSearch</span><span class="params">(<span name="query">query: <a href="../Query.html" class="extype" name="it.agilelab.bigdata.spark.search.Query">Query</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="../../../../../package.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="searchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">search(Query,Int,Int)</span>,
but returns the ids of the resulting elements.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="searchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">search(Query,Int,Int)</span>,
but returns the ids of the resulting elements.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd><dt>Note</dt><dd><span class="cmt"><p>These ids are ephemeral, and can change between instances of this RDD;
                     they are only meaningful when used in combination with the same RDD that
                     provided them.
</p></span></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#localCheckpoint" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="localCheckpoint():RDD.this.type"></a>
      <a id="localCheckpoint():PartitionsIndexLuceneRDD.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">localCheckpoint</span><span class="params">()</span><span class="result">: <a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a>.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.Logging#log" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="log:org.slf4j.Logger"></a>
      <a id="log:Logger"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">log</span><span class="result">: <span class="extype" name="org.slf4j.Logger">Logger</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logDebug" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logDebug(msg:=&gt;String,throwable:Throwable):Unit"></a>
      <a id="logDebug(⇒String,Throwable):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logDebug</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>, <span name="throwable">throwable: <span class="extype" name="scala.Throwable">Throwable</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logDebug" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logDebug(msg:=&gt;String):Unit"></a>
      <a id="logDebug(⇒String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logDebug</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logError" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logError(msg:=&gt;String,throwable:Throwable):Unit"></a>
      <a id="logError(⇒String,Throwable):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logError</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>, <span name="throwable">throwable: <span class="extype" name="scala.Throwable">Throwable</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logError" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logError(msg:=&gt;String):Unit"></a>
      <a id="logError(⇒String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logError</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logInfo" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logInfo(msg:=&gt;String,throwable:Throwable):Unit"></a>
      <a id="logInfo(⇒String,Throwable):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logInfo</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>, <span name="throwable">throwable: <span class="extype" name="scala.Throwable">Throwable</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logInfo" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logInfo(msg:=&gt;String):Unit"></a>
      <a id="logInfo(⇒String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logInfo</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logName" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logName:String"></a>
      <a id="logName:String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logName</span><span class="result">: <span class="extype" name="java.lang.String">String</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logTrace" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logTrace(msg:=&gt;String,throwable:Throwable):Unit"></a>
      <a id="logTrace(⇒String,Throwable):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logTrace</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>, <span name="throwable">throwable: <span class="extype" name="scala.Throwable">Throwable</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logTrace" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logTrace(msg:=&gt;String):Unit"></a>
      <a id="logTrace(⇒String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logTrace</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logWarning" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logWarning(msg:=&gt;String,throwable:Throwable):Unit"></a>
      <a id="logWarning(⇒String,Throwable):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logWarning</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>, <span name="throwable">throwable: <span class="extype" name="scala.Throwable">Throwable</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logWarning" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logWarning(msg:=&gt;String):Unit"></a>
      <a id="logWarning(⇒String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logWarning</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#map" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="map[U](f:T=&gt;U)(implicitevidence$3:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="map[U]((T)⇒U)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">map</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.map.U">U</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.map.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.map.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#mapPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="mapPartitions[U](f:Iterator[T]=&gt;Iterator[U],preservesPartitioning:Boolean)(implicitevidence$6:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="mapPartitions[U]((Iterator[T])⇒Iterator[U],Boolean)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">mapPartitions</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitions.U">U</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitions.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitions.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#mapPartitionsWithIndex" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="mapPartitionsWithIndex[U](f:(Int,Iterator[T])=&gt;Iterator[U],preservesPartitioning:Boolean)(implicitevidence$8:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="mapPartitionsWithIndex[U]((Int,Iterator[T])⇒Iterator[U],Boolean)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">mapPartitionsWithIndex</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a>, <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithIndex.U">U</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithIndex.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithIndex.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#max" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="max()(implicitord:Ordering[T]):T"></a>
      <a id="max()(Ordering[T]):T"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">max</span><span class="params">()</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#min" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="min()(implicitord:Ordering[T]):T"></a>
      <a id="min()(Ordering[T]):T"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">min</span><span class="params">()</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#name" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="name:String"></a>
      <a id="name:String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">name</span><span class="result">: <span class="extype" name="scala.Predef.String">String</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#ne" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="ne(x$1:AnyRef):Boolean"></a>
      <a id="ne(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">ne</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.AnyRef">AnyRef</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="scala.AnyRef#notify" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="notify():Unit"></a>
      <a id="notify():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">notify</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="scala.AnyRef#notifyAll" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="notifyAll():Unit"></a>
      <a id="notifyAll():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">notifyAll</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#numPartitions" visbl="pub" data-isabs="false" fullComment="no" group="Ungrouped">
      <a id="numPartitions:Int"></a>
      <a id="numPartitions:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">val</span>
      </span>
      <span class="symbol">
        <span class="name">numPartitions</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>
      </span>
      </h4>
      
    </li><li name="org.apache.spark.rdd.RDD#parent" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="parent[U](j:Int)(implicitevidence$36:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="parent[U](Int)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">parent</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="j">j: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.parent.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.parent.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a href="../../../../../../org$apache$spark.html" class="extype" name="org.apache.spark">org.apache.spark</a>] </dd><dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#partitioner" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="partitioner:Option[org.apache.spark.Partitioner]"></a>
      <a id="partitioner:Option[Partitioner]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">val</span>
      </span>
      <span class="symbol">
        <span class="name">partitioner</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Option" class="extype" target="_top">Option</a>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partitioner" class="extype" target="_top">Partitioner</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#partitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="partitions:Array[org.apache.spark.Partition]"></a>
      <a id="partitions:Array[Partition]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">partitions</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partition" class="extype" target="_top">Partition</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#persist" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="persist(storageLevel:org.apache.spark.storage.StorageLevel):PartitionsIndexLuceneRDD.this.type"></a>
      <a id="persist(StorageLevel):PartitionsIndexLuceneRDD.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">persist</span><span class="params">(<span name="storageLevel">storageLevel: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.storage.StorageLevel" class="extype" target="_top">StorageLevel</a></span>)</span><span class="result">: <a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a>.this.type</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Applies the storage level to both the underlying RDD of IndexedPartition
and this RDD
</p><div class="fullcomment"><div class="comment cmt"><p>Applies the storage level to both the underlying RDD of IndexedPartition
and this RDD
</p></div><dl class="paramcmts block"><dt class="param">storageLevel</dt><dd class="cmt"></dd><dt>returns</dt><dd class="cmt"><p>
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#persist" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="persist():RDD.this.type"></a>
      <a id="persist():PartitionsIndexLuceneRDD.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">persist</span><span class="params">()</span><span class="result">: <a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a>.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#pipe" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="pipe(command:Seq[String],env:scala.collection.Map[String,String],printPipeContext:(String=&gt;Unit)=&gt;Unit,printRDDElement:(T,String=&gt;Unit)=&gt;Unit,separateWorkingDir:Boolean):org.apache.spark.rdd.RDD[String]"></a>
      <a id="pipe(Seq[String],Map[String,String],((String)⇒Unit)⇒Unit,(T,(String)⇒Unit)⇒Unit,Boolean):RDD[String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">pipe</span><span class="params">(<span name="command">command: <span class="extype" name="scala.Seq">Seq</span>[<span class="extype" name="scala.Predef.String">String</span>]</span>, <span name="env">env: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.collection.Map" class="extype" target="_top">Map</a>[<span class="extype" name="scala.Predef.String">String</span>, <span class="extype" name="scala.Predef.String">String</span>]</span>, <span name="printPipeContext">printPipeContext: ((<span class="extype" name="scala.Predef.String">String</span>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>, <span name="printRDDElement">printRDDElement: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, (<span class="extype" name="scala.Predef.String">String</span>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>, <span name="separateWorkingDir">separateWorkingDir: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="scala.Predef.String">String</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#pipe" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="pipe(command:String,env:scala.collection.Map[String,String]):org.apache.spark.rdd.RDD[String]"></a>
      <a id="pipe(String,Map[String,String]):RDD[String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">pipe</span><span class="params">(<span name="command">command: <span class="extype" name="scala.Predef.String">String</span></span>, <span name="env">env: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.collection.Map" class="extype" target="_top">Map</a>[<span class="extype" name="scala.Predef.String">String</span>, <span class="extype" name="scala.Predef.String">String</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="scala.Predef.String">String</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#pipe" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="pipe(command:String):org.apache.spark.rdd.RDD[String]"></a>
      <a id="pipe(String):RDD[String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">pipe</span><span class="params">(<span name="command">command: <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="scala.Predef.String">String</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#preferredLocations" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="preferredLocations(split:org.apache.spark.Partition):Seq[String]"></a>
      <a id="preferredLocations(Partition):Seq[String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">preferredLocations</span><span class="params">(<span name="split">split: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partition" class="extype" target="_top">Partition</a></span>)</span><span class="result">: <span class="extype" name="scala.Seq">Seq</span>[<span class="extype" name="scala.Predef.String">String</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#queryJoin" visbl="pub" data-isabs="false" fullComment="yes" group="QueryJoin">
      <a id="queryJoin[U](other:org.apache.spark.rdd.RDD[U],queryGenerator:U=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int)(implicitevidence$1:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[(U,Array[(T,Double)])]"></a>
      <a id="queryJoin[U](RDD[U],(U)⇒DslQuery,Int)(ClassTag[U]):RDD[(U,Array[(T,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">queryJoin</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.queryJoin.U">U</span>]</span>, <span name="queryGenerator">queryGenerator: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.queryJoin.U">U</span>) ⇒ <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.queryJoin.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.queryJoin.U">U</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns an <code>RDD</code> that contains the result of the query join between <code>this</code> and <code>other</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Returns an <code>RDD</code> that contains the result of the query join between <code>this</code> and <code>other</code>.</p><p>A query join is a join in which the predicate is a query. From each element of <code>other</code>, a query
is obtained by applying <code>queryGenerator</code>. Then each query is ran against <code>this</code>, and the
<code>maxHits</code> results produced are joined with the element originating the query.</p><p>Queries are executed in batches, with a batch for each partition of <code>other</code>.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#queryJoin" visbl="pub" data-isabs="false" fullComment="yes" group="QueryJoin">
      <a id="queryJoin(queryGenerator:T=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int):org.apache.spark.rdd.RDD[(T,Array[(T,Double)])]"></a>
      <a id="queryJoin((T)⇒DslQuery,Int):RDD[(T,Array[(T,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">queryJoin</span><span class="params">(<span name="queryGenerator">queryGenerator: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="queryJoinWithResultsTransformer[U](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int)*">queryJoin[U](RDD[U],U=&gt;DslQuery,Int)</span>,
but with <code>this</code> as the <code>other</code> RDD; that is, a query self join.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="queryJoinWithResultsTransformer[U](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int)*">queryJoin[U](RDD[U],U=&gt;DslQuery,Int)</span>,
but with <code>this</code> as the <code>other</code> RDD; that is, a query self join.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#queryJoinWithResultsTransformer" visbl="pub" data-isabs="false" fullComment="yes" group="QueryJoin">
      <a id="queryJoinWithResultsTransformer[U,V](other:org.apache.spark.rdd.RDD[U],queryGenerator:U=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int,resultsTransformer:T=&gt;V)(implicitevidence$2:scala.reflect.ClassTag[U],implicitevidence$3:scala.reflect.ClassTag[V]):org.apache.spark.rdd.RDD[(U,Array[(V,Double)])]"></a>
      <a id="queryJoinWithResultsTransformer[U,V](RDD[U],(U)⇒DslQuery,Int,(T)⇒V)(ClassTag[U],ClassTag[V]):RDD[(U,Array[(V,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">queryJoinWithResultsTransformer</span><span class="tparams">[<span name="U">U</span>, <span name="V">V</span>]</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.queryJoinWithResultsTransformer.U">U</span>]</span>, <span name="queryGenerator">queryGenerator: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.queryJoinWithResultsTransformer.U">U</span>) ⇒ <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="resultsTransformer">resultsTransformer: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.queryJoinWithResultsTransformer.V">V</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.queryJoinWithResultsTransformer.U">U</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.queryJoinWithResultsTransformer.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.queryJoinWithResultsTransformer.U">U</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.queryJoinWithResultsTransformer.V">V</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="queryJoinWithResultsTransformer[U](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int)*">queryJoin[U](RDD[U],U=&gt;DslQuery,Int)</span>,
but specifying a <code>resultsTransformer</code> function to be applied to the result elements.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="queryJoinWithResultsTransformer[U](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int)*">queryJoin[U](RDD[U],U=&gt;DslQuery,Int)</span>,
but specifying a <code>resultsTransformer</code> function to be applied to the result elements.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#queryJoinWithResultsTransformer" visbl="pub" data-isabs="false" fullComment="yes" group="QueryJoin">
      <a id="queryJoinWithResultsTransformer[V](queryGenerator:T=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int,resultsTransformer:T=&gt;V)(implicitevidence$2:scala.reflect.ClassTag[V]):org.apache.spark.rdd.RDD[(T,Array[(V,Double)])]"></a>
      <a id="queryJoinWithResultsTransformer[V]((T)⇒DslQuery,Int,(T)⇒V)(ClassTag[V]):RDD[(T,Array[(V,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">queryJoinWithResultsTransformer</span><span class="tparams">[<span name="V">V</span>]</span><span class="params">(<span name="queryGenerator">queryGenerator: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="resultsTransformer">resultsTransformer: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.V">V</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.V">V</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="queryJoinWithResultsTransformer[U,V](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int,transformer:T=&gt;V)*">queryJoin[U,V](RDD[U],U=&gt;DslQuery,Int,T=&gt;V)</span>,
but with <code>this</code> as the <code>other</code> RDD; that is, a query self join.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="queryJoinWithResultsTransformer[U,V](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int,transformer:T=&gt;V)*">queryJoin[U,V](RDD[U],U=&gt;DslQuery,Int,T=&gt;V)</span>,
but with <code>this</code> as the <code>other</code> RDD; that is, a query self join.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#randomSplit" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="randomSplit(weights:Array[Double],seed:Long):Array[org.apache.spark.rdd.RDD[T]]"></a>
      <a id="randomSplit(Array[Double],Long):Array[RDD[T]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">randomSplit</span><span class="params">(<span name="weights">weights: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>]</span>, <span name="seed">seed: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#reduce" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="reduce(f:(T,T)=&gt;T):T"></a>
      <a id="reduce((T,T)⇒T):T"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduce</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span></span>)</span><span class="result">: <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#repartition" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="repartition(numPartitions:Int)(implicitord:Ordering[T]):org.apache.spark.rdd.RDD[T]"></a>
      <a id="repartition(Int)(Ordering[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">repartition</span><span class="params">(<span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#sample" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="sample(withReplacement:Boolean,fraction:Double,seed:Long):org.apache.spark.rdd.RDD[T]"></a>
      <a id="sample(Boolean,Double,Long):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sample</span><span class="params">(<span name="withReplacement">withReplacement: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>, <span name="fraction">fraction: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a></span>, <span name="seed">seed: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#saveAsObjectFile" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="saveAsObjectFile(path:String):Unit"></a>
      <a id="saveAsObjectFile(String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">saveAsObjectFile</span><span class="params">(<span name="path">path: <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#saveAsTextFile" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="saveAsTextFile(path:String,codec:Class[_&lt;:org.apache.hadoop.io.compress.CompressionCodec]):Unit"></a>
      <a id="saveAsTextFile(String,Class[_&lt;:CompressionCodec]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">saveAsTextFile</span><span class="params">(<span name="path">path: <span class="extype" name="scala.Predef.String">String</span></span>, <span name="codec">codec: <span class="extype" name="scala.Predef.Class">Class</span>[_ &lt;: <span class="extype" name="org.apache.hadoop.io.compress.CompressionCodec">CompressionCodec</span>]</span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#saveAsTextFile" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="saveAsTextFile(path:String):Unit"></a>
      <a id="saveAsTextFile(String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">saveAsTextFile</span><span class="params">(<span name="path">path: <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#search" visbl="pub" data-isabs="false" fullComment="yes" group="Search">
      <a id="search(query:it.agilelab.bigdata.spark.search.Query,maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(T,Double)]"></a>
      <a id="search(Query,Int,Int):RDD[(T,Double)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">search</span><span class="params">(<span name="query">query: <a href="../Query.html" class="extype" name="it.agilelab.bigdata.spark.search.Query">Query</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="../../../../../package.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns an <code>RDD</code> of elements matching the <code>query</code>, returning at most <code>maxHits</code> results.</p><div class="fullcomment"><div class="comment cmt"><p>Returns an <code>RDD</code> of elements matching the <code>query</code>, returning at most <code>maxHits</code> results.</p><p>Setting <code>maxHitsPerIndex</code> limits the size of intermediate results. It must be a positive value
between <code>1</code> and <code>maxHits</code> (both inclusive). The (internally handled) default is <code>maxHits</code>.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd><dt>Note</dt><dd><span class="cmt"><p>Setting the maximum number of intermediate results to be lower than
                            the maximum number of results can lead to good results not being
                            returned, especially with non-uniform data distributions.
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#searchWithResultsTransformer" visbl="pub" data-isabs="false" fullComment="yes" group="Search">
      <a id="searchWithResultsTransformer[V](query:it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int,resultsTransformer:T=&gt;V,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(V,Double)]"></a>
      <a id="searchWithResultsTransformer[V](DslQuery,Int,(T)⇒V,Int):RDD[(V,Double)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">searchWithResultsTransformer</span><span class="tparams">[<span name="V">V</span>]</span><span class="params">(<span name="query">query: <a href="../dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="resultsTransformer">resultsTransformer: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.searchWithResultsTransformer.V">V</span></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="../../../../../package.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.searchWithResultsTransformer.V">V</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="searchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">search(Query,Int,Int)</span>,
but specifying a <code>resultsTransformer</code> function to be applied to the result elements.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="searchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">search(Query,Int,Int)</span>,
but specifying a <code>resultsTransformer</code> function to be applied to the result elements.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#setName" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="setName(_name:String):PartitionsIndexLuceneRDD.this.type"></a>
      <a id="setName(String):PartitionsIndexLuceneRDD.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">setName</span><span class="params">(<span name="_name">_name: <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a>.this.type</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Set the name for the RDD; By default set to &quot;LuceneRDD&quot;</p><div class="fullcomment"><div class="comment cmt"><p>Set the name for the RDD; By default set to &quot;LuceneRDD&quot;</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#sortBy" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="sortBy[K](f:T=&gt;K,ascending:Boolean,numPartitions:Int)(implicitord:Ordering[K],implicitctag:scala.reflect.ClassTag[K]):org.apache.spark.rdd.RDD[T]"></a>
      <a id="sortBy[K]((T)⇒K,Boolean,Int)(Ordering[K],ClassTag[K]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sortBy</span><span class="tparams">[<span name="K">K</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.sortBy.K">K</span></span>, <span name="ascending">ascending: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>, <span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="org.apache.spark.rdd.RDD.sortBy.K">K</span>]</span>, <span name="ctag">ctag: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.sortBy.K">K</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#sparkContext" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="sparkContext:org.apache.spark.SparkContext"></a>
      <a id="sparkContext:SparkContext"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sparkContext</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.SparkContext" class="extype" target="_top">SparkContext</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#subtract" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="subtract(other:org.apache.spark.rdd.RDD[T],p:org.apache.spark.Partitioner)(implicitord:Ordering[T]):org.apache.spark.rdd.RDD[T]"></a>
      <a id="subtract(RDD[T],Partitioner)(Ordering[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">subtract</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>, <span name="p">p: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partitioner" class="extype" target="_top">Partitioner</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#subtract" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="subtract(other:org.apache.spark.rdd.RDD[T],numPartitions:Int):org.apache.spark.rdd.RDD[T]"></a>
      <a id="subtract(RDD[T],Int):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">subtract</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>, <span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#subtract" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="subtract(other:org.apache.spark.rdd.RDD[T]):org.apache.spark.rdd.RDD[T]"></a>
      <a id="subtract(RDD[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">subtract</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#synchronized" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="synchronized[T0](x$1:=&gt;T0):T0"></a>
      <a id="synchronized[T0](⇒T0):T0"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">synchronized</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="params">(<span name="arg0">arg0: ⇒ <span class="extype" name="java.lang.AnyRef.synchronized.T0">T0</span></span>)</span><span class="result">: <span class="extype" name="java.lang.AnyRef.synchronized.T0">T0</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#take" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="take(num:Int):Array[T]"></a>
      <a id="take(Int):Array[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">take</span><span class="params">(<span name="num">num: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#takeOrdered" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="takeOrdered(num:Int)(implicitord:Ordering[T]):Array[T]"></a>
      <a id="takeOrdered(Int)(Ordering[T]):Array[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">takeOrdered</span><span class="params">(<span name="num">num: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#takeSample" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="takeSample(withReplacement:Boolean,num:Int,seed:Long):Array[T]"></a>
      <a id="takeSample(Boolean,Int,Long):Array[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">takeSample</span><span class="params">(<span name="withReplacement">withReplacement: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>, <span name="num">num: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="seed">seed: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#toDebugString" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="toDebugString():String"></a>
      <a id="toDebugString():String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toDebugString</span><span class="params">()</span><span class="result">: <span class="extype" name="scala.Predef.String">String</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#toJavaRDD" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="toJavaRDD():org.apache.spark.api.java.JavaRDD[T]"></a>
      <a id="toJavaRDD():JavaRDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toJavaRDD</span><span class="params">()</span><span class="result">: <span class="extype" name="org.apache.spark.api.java.JavaRDD">JavaRDD</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#toLocalIterator" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="toLocalIterator:Iterator[T]"></a>
      <a id="toLocalIterator:Iterator[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toLocalIterator</span><span class="result">: <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#toString" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="toString():String"></a>
      <a id="toString():String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toString</span><span class="params">()</span><span class="result">: <span class="extype" name="scala.Predef.String">String</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD → AnyRef → Any</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#top" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="top(num:Int)(implicitord:Ordering[T]):Array[T]"></a>
      <a id="top(Int)(Ordering[T]):Array[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">top</span><span class="params">(<span name="num">num: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#treeAggregate" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="treeAggregate[U](zeroValue:U)(seqOp:(U,T)=&gt;U,combOp:(U,U)=&gt;U,depth:Int)(implicitevidence$34:scala.reflect.ClassTag[U]):U"></a>
      <a id="treeAggregate[U](U)((U,T)⇒U,(U,U)⇒U,Int)(ClassTag[U]):U"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">treeAggregate</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="zeroValue">zeroValue: <span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span></span>)</span><span class="params">(<span name="seqOp">seqOp: (<span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span>, <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span></span>, <span name="combOp">combOp: (<span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span>, <span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span></span>, <span name="depth">depth: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span>]</span>)</span><span class="result">: <span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#treeReduce" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="treeReduce(f:(T,T)=&gt;T,depth:Int):T"></a>
      <a id="treeReduce((T,T)⇒T,Int):T"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">treeReduce</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span></span>, <span name="depth">depth: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#union" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="union(other:org.apache.spark.rdd.RDD[T]):org.apache.spark.rdd.RDD[T]"></a>
      <a id="union(RDD[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">union</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD#unpersist" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="unpersist(blocking:Boolean):PartitionsIndexLuceneRDD.this.type"></a>
      <a id="unpersist(Boolean):PartitionsIndexLuceneRDD.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">unpersist</span><span class="params">(<span name="blocking">blocking: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a> = <span class="symbol">true</span></span>)</span><span class="result">: <a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a>.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a href="" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a> → RDD</dd></dl></div>
    </li><li name="scala.AnyRef#wait" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="wait():Unit"></a>
      <a id="wait():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">wait</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">(<span>
      
      <span class="defval" name="classOf[java.lang.InterruptedException]">...</span>
    </span>)</span>
              
        </dd></dl></div>
    </li><li name="scala.AnyRef#wait" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="wait(x$1:Long,x$2:Int):Unit"></a>
      <a id="wait(Long,Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">wait</span><span class="params">(<span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">(<span>
      
      <span class="defval" name="classOf[java.lang.InterruptedException]">...</span>
    </span>)</span>
              
        </dd></dl></div>
    </li><li name="scala.AnyRef#wait" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="wait(x$1:Long):Unit"></a>
      <a id="wait(Long):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">wait</span><span class="params">(<span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">(<span>
      
      <span class="defval" name="classOf[java.lang.InterruptedException]">...</span>
    </span>)</span>
              
        </dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zip" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zip[U](other:org.apache.spark.rdd.RDD[U])(implicitevidence$13:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[(T,U)]"></a>
      <a id="zip[U](RDD[U])(ClassTag[U]):RDD[(T,U)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zip</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zip.U">U</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zip.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.zip.U">U</span>)]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipPartitions[B,C,D,V](rdd2:org.apache.spark.rdd.RDD[B],rdd3:org.apache.spark.rdd.RDD[C],rdd4:org.apache.spark.rdd.RDD[D])(f:(Iterator[T],Iterator[B],Iterator[C],Iterator[D])=&gt;Iterator[V])(implicitevidence$28:scala.reflect.ClassTag[B],implicitevidence$29:scala.reflect.ClassTag[C],implicitevidence$30:scala.reflect.ClassTag[D],implicitevidence$31:scala.reflect.ClassTag[V]):org.apache.spark.rdd.RDD[V]"></a>
      <a id="zipPartitions[B,C,D,V](RDD[B],RDD[C],RDD[D])((Iterator[T],Iterator[B],Iterator[C],Iterator[D])⇒Iterator[V])(ClassTag[B],ClassTag[C],ClassTag[D],ClassTag[V]):RDD[V]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipPartitions</span><span class="tparams">[<span name="B">B</span>, <span name="C">C</span>, <span name="D">D</span>, <span name="V">V</span>]</span><span class="params">(<span name="rdd2">rdd2: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="rdd3">rdd3: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="rdd4">rdd4: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.D">D</span>]</span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.D">D</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="arg2">arg2: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.D">D</span>]</span>, <span name="arg3">arg3: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipPartitions[B,C,D,V](rdd2:org.apache.spark.rdd.RDD[B],rdd3:org.apache.spark.rdd.RDD[C],rdd4:org.apache.spark.rdd.RDD[D],preservesPartitioning:Boolean)(f:(Iterator[T],Iterator[B],Iterator[C],Iterator[D])=&gt;Iterator[V])(implicitevidence$24:scala.reflect.ClassTag[B],implicitevidence$25:scala.reflect.ClassTag[C],implicitevidence$26:scala.reflect.ClassTag[D],implicitevidence$27:scala.reflect.ClassTag[V]):org.apache.spark.rdd.RDD[V]"></a>
      <a id="zipPartitions[B,C,D,V](RDD[B],RDD[C],RDD[D],Boolean)((Iterator[T],Iterator[B],Iterator[C],Iterator[D])⇒Iterator[V])(ClassTag[B],ClassTag[C],ClassTag[D],ClassTag[V]):RDD[V]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipPartitions</span><span class="tparams">[<span name="B">B</span>, <span name="C">C</span>, <span name="D">D</span>, <span name="V">V</span>]</span><span class="params">(<span name="rdd2">rdd2: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="rdd3">rdd3: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="rdd4">rdd4: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.D">D</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.D">D</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="arg2">arg2: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.D">D</span>]</span>, <span name="arg3">arg3: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipPartitions[B,C,V](rdd2:org.apache.spark.rdd.RDD[B],rdd3:org.apache.spark.rdd.RDD[C])(f:(Iterator[T],Iterator[B],Iterator[C])=&gt;Iterator[V])(implicitevidence$21:scala.reflect.ClassTag[B],implicitevidence$22:scala.reflect.ClassTag[C],implicitevidence$23:scala.reflect.ClassTag[V]):org.apache.spark.rdd.RDD[V]"></a>
      <a id="zipPartitions[B,C,V](RDD[B],RDD[C])((Iterator[T],Iterator[B],Iterator[C])⇒Iterator[V])(ClassTag[B],ClassTag[C],ClassTag[V]):RDD[V]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipPartitions</span><span class="tparams">[<span name="B">B</span>, <span name="C">C</span>, <span name="V">V</span>]</span><span class="params">(<span name="rdd2">rdd2: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="rdd3">rdd3: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="arg2">arg2: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipPartitions[B,C,V](rdd2:org.apache.spark.rdd.RDD[B],rdd3:org.apache.spark.rdd.RDD[C],preservesPartitioning:Boolean)(f:(Iterator[T],Iterator[B],Iterator[C])=&gt;Iterator[V])(implicitevidence$18:scala.reflect.ClassTag[B],implicitevidence$19:scala.reflect.ClassTag[C],implicitevidence$20:scala.reflect.ClassTag[V]):org.apache.spark.rdd.RDD[V]"></a>
      <a id="zipPartitions[B,C,V](RDD[B],RDD[C],Boolean)((Iterator[T],Iterator[B],Iterator[C])⇒Iterator[V])(ClassTag[B],ClassTag[C],ClassTag[V]):RDD[V]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipPartitions</span><span class="tparams">[<span name="B">B</span>, <span name="C">C</span>, <span name="V">V</span>]</span><span class="params">(<span name="rdd2">rdd2: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="rdd3">rdd3: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="arg2">arg2: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipPartitions[B,V](rdd2:org.apache.spark.rdd.RDD[B])(f:(Iterator[T],Iterator[B])=&gt;Iterator[V])(implicitevidence$16:scala.reflect.ClassTag[B],implicitevidence$17:scala.reflect.ClassTag[V]):org.apache.spark.rdd.RDD[V]"></a>
      <a id="zipPartitions[B,V](RDD[B])((Iterator[T],Iterator[B])⇒Iterator[V])(ClassTag[B],ClassTag[V]):RDD[V]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipPartitions</span><span class="tparams">[<span name="B">B</span>, <span name="V">V</span>]</span><span class="params">(<span name="rdd2">rdd2: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipPartitions[B,V](rdd2:org.apache.spark.rdd.RDD[B],preservesPartitioning:Boolean)(f:(Iterator[T],Iterator[B])=&gt;Iterator[V])(implicitevidence$14:scala.reflect.ClassTag[B],implicitevidence$15:scala.reflect.ClassTag[V]):org.apache.spark.rdd.RDD[V]"></a>
      <a id="zipPartitions[B,V](RDD[B],Boolean)((Iterator[T],Iterator[B])⇒Iterator[V])(ClassTag[B],ClassTag[V]):RDD[V]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipPartitions</span><span class="tparams">[<span name="B">B</span>, <span name="V">V</span>]</span><span class="params">(<span name="rdd2">rdd2: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipWithIndex" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipWithIndex():org.apache.spark.rdd.RDD[(T,Long)]"></a>
      <a id="zipWithIndex():RDD[(T,Long)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipWithIndex</span><span class="params">()</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>)]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipWithUniqueId" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipWithUniqueId():org.apache.spark.rdd.RDD[(T,Long)]"></a>
      <a id="zipWithUniqueId():RDD[(T,Long)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipWithUniqueId</span><span class="params">()</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>)]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li></ol>
            </div>

        

        <div id="values" class="values members">
              <h3>Deprecated Value Members</h3>
              <ol><li name="org.apache.spark.rdd.RDD#filterWith" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="filterWith[A](constructA:Int=&gt;A)(p:(T,A)=&gt;Boolean):org.apache.spark.rdd.RDD[T]"></a>
      <a id="filterWith[A]((Int)⇒A)((T,A)⇒Boolean):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 1.0.0) use mapPartitionsWithIndex and filter">filterWith</span><span class="tparams">[<span name="A">A</span>]</span><span class="params">(<span name="constructA">constructA: (<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.filterWith.A">A</span></span>)</span><span class="params">(<span name="p">p: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.filterWith.A">A</span>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 1.0.0)</i> use mapPartitionsWithIndex and filter</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#flatMapWith" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="flatMapWith[A,U](constructA:Int=&gt;A,preservesPartitioning:Boolean)(f:(T,A)=&gt;Seq[U])(implicitevidence$12:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="flatMapWith[A,U]((Int)⇒A,Boolean)((T,A)⇒Seq[U])(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 1.0.0) use mapPartitionsWithIndex and flatMap">flatMapWith</span><span class="tparams">[<span name="A">A</span>, <span name="U">U</span>]</span><span class="params">(<span name="constructA">constructA: (<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.flatMapWith.A">A</span></span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.flatMapWith.A">A</span>) ⇒ <span class="extype" name="scala.Seq">Seq</span>[<span class="extype" name="org.apache.spark.rdd.RDD.flatMapWith.U">U</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.flatMapWith.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.flatMapWith.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 1.0.0)</i> use mapPartitionsWithIndex and flatMap</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#foreachWith" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="foreachWith[A](constructA:Int=&gt;A)(f:(T,A)=&gt;Unit):Unit"></a>
      <a id="foreachWith[A]((Int)⇒A)((T,A)⇒Unit):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 1.0.0) use mapPartitionsWithIndex and foreach">foreachWith</span><span class="tparams">[<span name="A">A</span>]</span><span class="params">(<span name="constructA">constructA: (<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.foreachWith.A">A</span></span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.foreachWith.A">A</span>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 1.0.0)</i> use mapPartitionsWithIndex and foreach</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#mapPartitionsWithContext" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="mapPartitionsWithContext[U](f:(org.apache.spark.TaskContext,Iterator[T])=&gt;Iterator[U],preservesPartitioning:Boolean)(implicitevidence$9:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="mapPartitionsWithContext[U]((TaskContext,Iterator[T])⇒Iterator[U],Boolean)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 1.2.0) use TaskContext.get">mapPartitionsWithContext</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.TaskContext" class="extype" target="_top">TaskContext</a>, <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithContext.U">U</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithContext.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithContext.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@DeveloperApi</span><span class="args">()</span>
              
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 1.2.0)</i> use TaskContext.get</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#mapPartitionsWithSplit" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="mapPartitionsWithSplit[U](f:(Int,Iterator[T])=&gt;Iterator[U],preservesPartitioning:Boolean)(implicitevidence$10:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="mapPartitionsWithSplit[U]((Int,Iterator[T])⇒Iterator[U],Boolean)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 0.7.0) use mapPartitionsWithIndex">mapPartitionsWithSplit</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a>, <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithSplit.U">U</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithSplit.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithSplit.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 0.7.0)</i> use mapPartitionsWithIndex</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#mapWith" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="mapWith[A,U](constructA:Int=&gt;A,preservesPartitioning:Boolean)(f:(T,A)=&gt;U)(implicitevidence$11:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="mapWith[A,U]((Int)⇒A,Boolean)((T,A)⇒U)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 1.0.0) use mapPartitionsWithIndex">mapWith</span><span class="tparams">[<span name="A">A</span>, <span name="U">U</span>]</span><span class="params">(<span name="constructA">constructA: (<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.mapWith.A">A</span></span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.mapWith.A">A</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.mapWith.U">U</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapWith.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapWith.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 1.0.0)</i> use mapPartitionsWithIndex</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#toArray" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="toArray():Array[T]"></a>
      <a id="toArray():Array[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 1.0.0) use collect">toArray</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 1.0.0)</i> use collect</p></dd></dl></div>
    </li></ol>
            </div>
        </div>

        <div id="inheritedMembers">
        <div class="parent" name="it.agilelab.bigdata.spark.search.SearchableRDD">
              <h3>Inherited from <a href="../SearchableRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</h3>
            </div><div class="parent" name="org.apache.spark.rdd.RDD">
              <h3>Inherited from <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD.T">T</span>]</h3>
            </div><div class="parent" name="org.apache.spark.Logging">
              <h3>Inherited from <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Logging" class="extype" target="_top">Logging</a></h3>
            </div><div class="parent" name="scala.Serializable">
              <h3>Inherited from <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Serializable" class="extype" target="_top">Serializable</a></h3>
            </div><div class="parent" name="java.io.Serializable">
              <h3>Inherited from <span class="extype" name="java.io.Serializable">Serializable</span></h3>
            </div><div class="parent" name="scala.AnyRef">
              <h3>Inherited from <span class="extype" name="scala.AnyRef">AnyRef</span></h3>
            </div><div class="parent" name="scala.Any">
              <h3>Inherited from <span class="extype" name="scala.Any">Any</span></h3>
            </div>
        
        </div>

        <div id="groupedMembers">
        <div class="group" name="QueryJoin">
              <h3>QueryJoin</h3>
              
            </div><div class="group" name="Search">
              <h3>Search</h3>
              
            </div><div class="group" name="Ungrouped">
              <h3>Ungrouped</h3>
              
            </div>
        </div>

      </div>

      <div id="tooltip"></div>

      <div id="footer">  </div>
      <script defer="defer" type="text/javascript" id="jquery-js" src="../../../../../../lib/jquery.js"></script><script defer="defer" type="text/javascript" id="jquery-ui-js" src="../../../../../../lib/jquery-ui.js"></script><script defer="defer" type="text/javascript" id="tools-tooltip-js" src="../../../../../../lib/tools.tooltip.js"></script><script defer="defer" type="text/javascript" id="template-js" src="../../../../../../lib/template.js"></script>
    </body>
      </html>